回文素数
def is_prime(num):
    """检查一个数字是否为素数"""
    if num <= 1:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def is_palindrome(num):
    """检查一个数字是否为回文"""
    return str(num) == str(num)[::-1]

def find_palindromic_primes(n):
    """找出前 n 个回文素数"""
    palindromic_primes = []
    num = 2  # 从2开始查找素数
    
    while len(palindromic_primes) < n:
        if is_prime(num) and is_palindrome(num):
            palindromic_primes.append(num)
        num += 1
    
    return palindromic_primes

# 用户输入
n = int(input())
palindromic_primes = find_palindromic_primes(n)
print(" ".join(map(str, palindromic_primes)))

反素数
def is_prime(num):
    """检查一个数字是否为素数"""
    if num <= 1:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def reverse_number(num):
    """将数字反转并返回"""
    return int(str(num)[::-1])

def is_non_palindromic(num):
    """检查数字是否为非回文"""
    return str(num) != str(num)[::-1]

def find_reverse_primes(n):
    """找出前 n 个反素数"""
    reverse_primes = []
    num = 2  # 从2开始查找素数
    
    while len(reverse_primes) < n:
        if is_prime(num) and is_non_palindromic(num):
            reversed_num = reverse_number(num)
            if is_prime(reversed_num):
                reverse_primes.append(num)
        num += 1
    
    return reverse_primes

# 用户输入
n = int(input())
reverse_primes = find_reverse_primes(n)
print(" ".join(map(str, reverse_primes)) + " ")

股票赢亏计算函数
第1关：股票收益计算
a=(15*5500)*(1+0.1)**(15)-15*5500
print(f'{a:.2f}')

第2关：股票收益计算函数
def money_made(num_shares, purchase_share_price, current_share_price):
    """
    计算股票交易的收益。

    参数:
    num_shares (int): 购买的股票数量。
    purchase_share_price (float): 每股的购买价格。
    current_share_price (float): 当前每股的价格。

    返回:
    float: 股票交易的收益，计算公式为股票数量乘以每股的价格差。
    """
    # 补充计算语句和返回值语句
    a=num_shares *(current_share_price-purchase_share_price)
    
    return a



# 主程序输入部分
num = int(input())
purchase = float(input())
current = float(input())
# 补充调用函数获取计算结果的语句
result=money_made(num, purchase, current)
print(f'{result:.1f}')
# 补充输出结果的语句，保留2位小数

4.2 自定义数学函数(project)
第1关：pow函数详解
def pow(x, n):  # 幂运算函数
    """接收一个数字x和一个整数n为参数,返回x的n次幂的结果的浮点数类型
    要求使pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0"""
    #########################Begin############################### 
    result=x**n
    return result



    #########################End############################### 



if __name__ == '__main__':
    x = float(input())
    n = int(input())
    return_data = pow(x,n)
    print(return_data)

第2关：最大公约数
def gcd(a, b):
    """接收两个正整数为参数，返回两个数的最大公约数"""
    #######################Begin############################
    m = max(a, b)
    n = min(a, b)
    r = m % n
    while r != 0:
        m = n
        n = r
        r = m % n
    return n




    #######################End############################

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    return_data = gcd(a,b)
    print(return_data)

第3关：最小公倍数
def lcm(a, b):
    """接收两个正整数为参数，以整数类型返回两个数的最小公倍数"""
    ######################Begin###############################
    
    m = max(a,b)
    n = min(a,b)
    x = m * n  # x用于存放m与n的乘积
      # 此时输出m和n的值还没改变
    while m != n:
        if m > n:
            m = m - n
        else:
            n = n - m
    return x//m




    ######################End###############################

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    return_data = lcm(a,b)
    print(return_data)

第4关：fabs() 函数
import math
def fabs(x):
    """返回x的绝对值"""
    ######################Begin###############################
    a=math.fabs(x)
    return a 




    ######################End###############################

if __name__ == '__main__':
    x = eval(input())
    return_data = fabs(x)
    print(return_data)

第5关：ceil() 函数
import math
def ceil(x):
    """接受一个浮点数或整数，返回大于或等于该数的最小整数"""
    ######################Begin###############################
    return math.ceil(x) # 101




    ######################End###############################

if __name__ == '__main__':
    x = eval(input())
    return_data = ceil(x)
    print(return_data)

第6关：floor()函数详解
import math
def floor(x):
    """接受一个浮点数或整数，返回不大于该数的最大整数"""
    ######################Begin###############################
    return math.floor(x)




    ######################End###############################
    
if __name__ == '__main__':
    x = eval(input())
    return_data = floor(x)
    print(return_data)

第7关：factorial函数详解
import math
def factorial(n):
    """接收一个非负整数n为参数，返回n的阶乘，0的阶乘值为1"""
    ######################Begin###############################
    return math.factorial(n)




    ######################End###############################

if __name__ == '__main__':
    x = int(input())
    return_data = factorial(x)
    print(return_data)

第8关：fsum函数
def fsum(iterable):
    """接收一个元素为数值的序列为参数，以浮点数类型返回各元素之和"""
    ######################Begin###############################
    return f'{sum(iterable):.1f}'



    ######################End###############################


if __name__ == '__main__':
    x = list(map(eval, input().split()))
    return_data = fsum(x)
    print(return_data)

4.3 素数及应用(project)
第1关：素数判定
def is_prime(n): 
    """判断素数的函数,接收一个正整数为参数，返回值是布尔类型。参数是素数时返回True，否则返回False"""
    #==================Begin=================================
    # 补充你的代码
    if n <= 1:
        return False  # 1 及以下的数不是素数
    for i in range(2, int(n**0.5) + 1):  # 只需检查到 n 的平方根
        if n % i == 0:
            return False  # 找到因子，说明 n 不是素数
    return True  # 未找到因子，n 是素数


    
    #===================End================================


positive_int = int(input())      # 输入一个正整数
if is_prime(positive_int):
    print(f'{positive_int}是素数') 
else:
    print(f'{positive_int}不是素数')

第2关：输出N以内的所有素数
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n <= 1:
        return False  # 1 及以下的数不是素数
    for i in range(2, int(n**0.5) + 1):  # 只需检查到 n 的平方根
        if n % i == 0:
            return False  # 找到因子，说明 n 不是素数
    return True  # 未找到因子，n 是素数

    #=======================End================================


def output_prime(number):
    """接收一个正整数为参数，遍历从0到number之间的所有整数
    在一行中输出不大于number的所有素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number+1):
        if is_prime(i):
            print(i,end=' ')
    #=======================End================================


positive_int = int(input())  
output_prime(positive_int)    

第3关：寻找回文素数
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n <= 1:
        return False  # 1 及以下的数不是素数
    for i in range(2, int(n**0.5) + 1):  # 只需检查到 n 的平方根
        if n % i == 0:
            return False  # 找到因子，说明 n 不是素数
    return True  # 未找到因子，n 是素数
    #=========================End==============================


def plalindrome_prime(number):
    """接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    找出并在同一行中输出小于number的所有回文素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number):
        if is_prime(i):
            i=str(i)
            if  i == i[::-1]:
                print(i,end=' ')
      
    #=========================End==============================




positive_int = int(input())         
plalindrome_prime(positive_int)      

第4关：寻找反素数
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n <= 1:
        return False  # 1 及以下的数不是素数
    for i in range(2, int(n**0.5) + 1):  # 只需检查到 n 的平方根
        if n % i == 0:
            return False  # 找到因子，说明 n 不是素数
    return True  # 未找到因子，n 是素数
    #========================End===============================


def reverse_prime(number):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，每个数字后一个空格。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串。函数无返回值"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number):
        if str(i)!=str(i)[::-1] and is_prime(i) and is_prime(int(str(i)[::-1])):
            
            print(i,end=' ')

                
    #========================End===============================


positive_int = int(input())         
reverse_prime(positive_int)     

第5关：哥德巴赫猜想
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False"""
    # ====================Begin===================================
    # 补充你的代码
    if n < 2:
        return False
    elif n == 2:
        return True
    else:
        a = int(n ** (1 / 2) + 1)
        for i in range(2, a + 1):
            if n % i == 0:
                return False
        return True
    # ======================End=================================
 
def goldbach_conjecture(num):
    """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
    当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
    有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
    参数为奇数或小于4时，输出'Data error!'
    """
    # ====================Begin===================================
    # 补充你的代码
 
    if 4<=num and num % 2 == 0:
        for i in range(1,num + 1):
            n = num - i
            if is_prime(i) and is_prime(n) and i<=n :
                print(f"{num}={i}+{n}")
    else:
        print('Data error!')
 
    # ======================End=================================
 
if __name__ == '__main__':
    positive_even = int(input())  # 输入一个正数
    goldbach_conjecture(positive_even)

Python第四章作业（初级）
第1关：无参无返回值函数
def print_hi_human():  # 函数名用小写字母
    """文档注释，双引号，说明函数的参数、功能和返回值等。
    定义一个名为print_hi_human的无参数函数，其功能是打印一句问候语，
    这个函数没有return语句，即没有返回值，或者说其返回值为None。
    # >>> print_hi_human()
    # 人类，你好！
    """
    # ==================Begin=====================================
    # 此处去掉注释符号“#”并补充你的代码
    print('人类，你好！')

    # ===================End====================================

if __name__ == '__main__':
    # 直接使用函数名来调用函数
    # ==================Begin=====================================
    # 此处去掉注释符号“#”并补充你的代码
    print_hi_human()

    # ===================End====================================

第2关：无参有返回值函数
def say_hi_human():  # 函数名用小写字母
    """定义一个名为print_hi_human的无参数函数，其功能是返回字符串-人类，你好！"""
    #========================Begin===============================
    #补充你的代码
    return '人类，你好！'

    #==========================End=============================

if __name__ == '__main__':
    # 函数名作为print()函数的参数，输出say_hi_human()的返回值
    #========================Begin===============================
    #补充你的代码
    print(say_hi_human())

    #==========================End============================

第3关：有参有返回值函数
def say_hi_person(full_name):  # 函数名用小写字母，函数名填空
    """定义一个名为say_hi_person的有参数函数，接受人名的字符串为参数，函数的返回值为“***，你好！”，
    例如函数的参数为“李白”，返回值为“李白，你好！”。"""
    #====================Begin===================================
    # 补充你的代码
    return f'{full_name}，你好！'

    #=====================End==================================

if __name__ == '__main__':
    #  函数名作为print()函数的参数，输出say_hi_human()的返回值。输入的人名作为函数的参数
    person_name = input()              # 输入人名
    #====================Begin===================================
    # 补充你的代码
    print(say_hi_person(person_name))

第4关：多参函数
def say_hi_gender(full_name, gender):  # name 和gender为形式参数
    """定义一个名为say_hi的有参数函数，其功能是打印一句问候语
    根据性别gender值确定称谓，男性称为“先生”，女性称为“女士”，不确定性别时称为“先生/女士”
    返回值为替换了姓名与称谓的欢迎字符串
    例如：尊敬的李白先生，欢迎来到火星！"""
    # ====================Begin===================================
    # 此处去掉注释符号“#”并补充你的代码
    if gender == "男":
        return f"尊敬的{full_name}先生，欢迎来到火星！"
    elif gender =="女":
        return f"尊敬的{full_name}女士，欢迎来到火星！"
    else:
        return f"尊敬的{full_name}先生/女士，欢迎来到火星！"
    # =======================================================
 
if __name__ == '__main__':
    # 直接使用函数名来调用函数
    # ====================Begin===================================
    # 此处去掉注释符号“#”并补充你的代码
    full_name = input()
    gender = input()
    print(say_hi_gender(full_name, gender))
    # =======================================================

第5关：任意数量参数
def say_hi_multi_parameter(*name):    # 括号里填上参数
    # 对齐此处补充代码
    for i in name:
        print(f'{i}，你好！')
 
 
#调用say_hi_multi_parameter并传入参数
say_hi_multi_parameter('孟浩然')
say_hi_multi_parameter('杜甫', '李白', '柳宗元', '李商隐')

第6关：pow函数详解
def pow(x, n):
    if n == 0:
        return 1.0
    elif n == 1:
        return x
    elif n %2 == 0:
        return pow(x**2,n//2)
    else:
        return pow(x**2,n//2)*x
if __name__ == '__main__':
    x = float(input())
    n = int(input())
    return_data = pow(x,n)
    print(return_data)

第7关：fabs() 函数
def fabs(x):
    """返回x的绝对值"""
    # 补充你的代码
    if x < 0:
        return float(-x)
    else:
        return float(x)




    

if __name__ == '__main__':
    n = float(input())
    print(fabs(n))

第8关：汽车迷
def Car(y,s,b='宝马'): # 括号里补充你的代码
    return f'这是一辆{y}年生产，型号是{s}的{b}牌汽车。'
 
# 以下内容不要修改
ls = input().split()  # 根据空格切分输入字符串为列表
print(Car(*ls))       # 调用函数，取列表中的全部数据做参数


第9关：编写函数输出自除数
n = int(input())
list = []
for i in range(1,n+1):
    if "0" in str(i):
        continue
    for m in str(i):
        if i % int(m)!=0:
            break
    else:
        list.append(i)
for n in list:
    print(n,end = " ")

第10关：二分法求平方根B
from math import sqrt
x, g = input().split(',')
def sqrt_binary(x,g):
    low = 0
    high = x + 0.25
    m = (low + high) / 2
    while abs(m ** 2 - x) > g:
        if m ** 2 < x:
            low = m
        else:
            high = m
        m = (low + high) / 2
    print(f'{m:.8f}')
    print(f'{sqrt(x):.8f}')
sqrt_binary(float(x), float(g))

实验四（AB）
第1关：素数判定函数
"""函数名is_prime()不允许修改，判断素数的函数,接收一个正整数为参数，返回值是布尔类型。参数是素数时返回True，否则返回False"""
'''本代码只用来定义函数，测试用例会通过调用本文件定义的函数来进行测试'''
def is_prime(n):
    if n < 2:
        return False
    elif n == 2:
        return True
    else:
        a = int(n ** (1 / 2) + 1)
        for i in range(2, a + 1):
            if n % i == 0:
                return False
        return True
     
第2关：寻找回文素数
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n <= 1:
        return False  # 1 及以下的数不是素数
    for i in range(2, int(n**0.5) + 1):  # 只需检查到 n 的平方根
        if n % i == 0:
            return False  # 找到因子，说明 n 不是素数
    return True  # 未找到因子，n 是素数
    #=========================End==============================


def plalindrome_prime(number):
    """接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    找出并在同一行中输出小于number的所有回文素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number):
        if is_prime(i):
            i=str(i)
            if  i == i[::-1]:
                print(i,end=' ')
      
    #=========================End==============================




positive_int = int(input())         
plalindrome_prime(positive_int)      

第3关：寻找反素数
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if n <= 1:
        return False  # 1 及以下的数不是素数
    for i in range(2, int(n**0.5) + 1):  # 只需检查到 n 的平方根
        if n % i == 0:
            return False  # 找到因子，说明 n 不是素数
    return True  # 未找到因子，n 是素数
    #========================End===============================


def reverse_prime(number):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，每个数字后一个空格。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串。函数无返回值"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(number):
        if str(i)!=str(i)[::-1] and is_prime(i) and is_prime(int(str(i)[::-1])):
            
            print(i,end=' ')

                
    #========================End===============================


positive_int = int(input())         
reverse_prime(positive_int)     

第4关：哥德巴赫猜想
def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False"""
    # ====================Begin===================================
    # 补充你的代码
    if n < 2:
        return False
    elif n == 2:
        return True
    else:
        a = int(n ** (1 / 2) + 1)
        for i in range(2, a + 1):
            if n % i == 0:
                return False
        return True
    # ======================End=================================
 
def goldbach_conjecture(num):
    """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
    当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
    有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
    参数为奇数或小于4时，输出'Data error!'
    """
    # ====================Begin===================================
    # 补充你的代码
 
    if 4<=num and num % 2 == 0:
        for i in range(1,num + 1):
            n = num - i
            if is_prime(i) and is_prime(n) and i<=n :
                print(f"{num}={i}+{n}")
    else:
        print('Data error!')
 
    # ======================End=================================
 
if __name__ == '__main__':
    positive_even = int(input())  # 输入一个正数
    goldbach_conjecture(positive_even)

第5关：本月天数
def is_leap(year):
    # 判断year是否为闰年，闰年返回True，非闰年返回False
    if (year % 100 != 0 and year % 4 == 0) or year % 400 == 0:
        return True
    else:
        return False
 
 
def days_of_month(year,month):
    # 根据输入的年月日，返回该月的天数
    tian = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if is_leap(year):
        tian[1] = 29
    print(tian[month-1])
 
str = input()
year = int(str[0:4])
month = int(str[4:6])
days_of_month(year,month)

第6关：华氏度转摄氏度速查表
def F2C(f):
        c=5*(f-32)/9
        return c
 
 
left,right=map(int,input().split(','))
if left>right:
    print('error')
else:
    for f in range(left,right+1,2):
        print("{} : {:.2f}".format(f,F2C(f)))

第7关：奇偶求和
def f(n):
    sum1 = 0
    for i in map(int, n):
        if i % 2!= 0:
           sum1+=i
    return sum1
 
def p(t):
    sum2 = 0
    for i in map(int, t):
        if i % 2 == 0:
            sum2 += i
    return sum2
 
 
s=input()
print('oddsum={},evensum={}'.format(f(s),p(s)))

第8关：字母查找
m = input()
flag = 0 #利用flag来统计m是否m中的所有字符都能匹配到n中
if (m.isalpha()):    #输入字符串n判断单词m是否可以由n中的某些字符组成
    n = input()      #m输入判断成功后再输入n，这样可以减少输入，如果m错了也不会报错
    for i in m:
        if i in n:
            flag += 1
    if flag == len(m):
        print('FOUND')
    else:
        print('NOT FOUND') 
else:               
    print('ERROR')



